package utility;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Point;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.PixelGrabber;

import javax.swing.ImageIcon;

public class ImageUtility
{
	public static Point extractPoint(int cols, int rows, int tileNum, int tileSize)
	{
		if (tileNum <= rows * cols)
		{
			int y = tileNum / cols;
			int x = tileNum % cols;
			return new Point(x * tileSize, y * tileSize);
		}
		else
			return null;
	}
    public static BufferedImage makeColorTransparent(Image image, Color color)
    {
    	BufferedImage dimg = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_ARGB);
        Graphics2D g = dimg.createGraphics();
        g.setComposite(AlphaComposite.Src);
        g.drawImage(image, 0, 0, null);
        g.dispose();
        for(int i = 0; i < dimg.getHeight(); i++)
        {
        	for(int j = 0; j < dimg.getWidth(); j++)
        	{
        		if(dimg.getRGB(j, i) == color.getRGB())
        		{
            		dimg.setRGB(j, i, 0x8F1C1C);  
            	}
            }
        }
        return dimg;
	}
    
    public static BufferedImage toBufferedImage(Image image)
    {
        if (image instanceof BufferedImage) {
            return (BufferedImage)image;
        }

        // This code ensures that all the pixels in the image are loaded
        image = new ImageIcon(image).getImage();

        // Determine if the image has transparent pixels; for this method's
        // implementation, see Determining If an Image Has Transparent Pixels
        boolean hasAlpha = hasAlpha(image);

        // Create a buffered image with a format that's compatible with the screen
        BufferedImage bimage = null;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        try
        {
            // Determine the type of transparency of the new buffered image
            int transparency = Transparency.OPAQUE;
            if (hasAlpha) {
                transparency = Transparency.BITMASK;
        }

            // Create the buffered image
            GraphicsDevice gs = ge.getDefaultScreenDevice();
            GraphicsConfiguration gc = gs.getDefaultConfiguration();
            bimage = gc.createCompatibleImage(
                image.getWidth(null), image.getHeight(null), transparency);
        }
        catch (HeadlessException e)
        {
            // The system does not have a screen
        }

        if (bimage == null)
        {
            // Create a buffered image using the default color model
            int type = BufferedImage.TYPE_INT_RGB;
            if (hasAlpha)
            {
                type = BufferedImage.TYPE_INT_ARGB;
            }
            bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
        }

        // Copy image to buffered image
        Graphics g = bimage.createGraphics();

        // Paint the image onto the buffered image
        g.drawImage(image, 0, 0, null);
        g.dispose();

        return bimage;
    }

    public static boolean hasAlpha(Image image)
    {
    	// If buffered image, the color model is readily available
    	if (image instanceof BufferedImage)
    	{
        BufferedImage bimage = (BufferedImage)image;
        return bimage.getColorModel().hasAlpha();
    	}

    	// Use a pixel grabber to retrieve the image's color model;
    	// grabbing a single pixel is usually sufficient
    	PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
    	try
    	{
    		pg.grabPixels();
    	}
    	catch (InterruptedException e)
    	{
    	}

    	// Get the image's color model
    	ColorModel cm = pg.getColorModel();
    	return cm.hasAlpha();
    }
    
    public static BufferedImage[] splitImage(BufferedImage img, int cols, int rows)
    {
    	int tileWidth = img.getWidth()/cols;
    	int tileHeight = img.getHeight()/rows;
    	int num = 0;
    	
    	BufferedImage[] imgs = new BufferedImage[rows * cols];
    	
    	for (int i = 0; i < rows; i++)
    	{
    		for (int k = 0; k < cols; k++)
    		{
    			imgs[num] = new BufferedImage(tileWidth, tileHeight, BufferedImage.TYPE_INT_ARGB);
    			Graphics2D g = imgs[num].createGraphics();
    			g.drawImage(makeColorTransparent(img, new Color(255, 0, 255)), 0, 0, tileWidth, tileHeight, k * tileWidth, i * tileHeight, k * tileWidth + tileWidth, i * tileHeight + tileHeight, null);
    			g.dispose();
    			num++;
    		}
    	}
    	return imgs;
    }
}

